home *** CD-ROM | disk | FTP | other *** search
/ PC World Interactive 7 / PC World Interactive 7.iso / program / cprog.EXE / C10.TXT < prev    next >
Text File  |  1996-07-05  |  12KB  |  364 lines
  1. C Dili - 10. Konu
  2.  
  3. BIR KUTUGE YAZMAK
  4.  
  5. ONSATIR.C:
  6. ================================================================
  7. #include <stdio.h>
  8. main()
  9. {
  10. FILE *fp;
  11. char ivir[25];
  12. int index;
  13.  
  14.    fp = fopen("ONSATIR.TXT","w");   /* yazmak icin acalim */
  15.    strcpy(ivir,"Bu bir ornek satirdir.");
  16.  
  17.    for (index = 1;index <= 10;index++)
  18.       fprintf(fp,"%s  Satir no: %d\n",ivir,index);
  19.  
  20.    fclose(fp);    /* Kutugu kapayalim */
  21. }
  22. ================================================================
  23.  
  24. Bir kutuge yazan ilk programimiz. Herzamanki gibi, "stdio.h" i programa
  25. ekliyoruz, ve daha sonra cok tuhaf bir degisken tanimliyoruz.
  26.  
  27. "FILE" tipi, bir kutuk degiskenidir, ve "stdio.h" in icinde
  28. tanimlanmistir. Kullanacagimiz kutuge erismek icin bir 'kutuk pointeri'
  29. tanimlamaktadir. 
  30.  
  31. KUTUGUN ACILMASI
  32.  
  33. Bir kutuge yazmadan once, onu acmamiz gereklidir. Acmak demek, sisteme o
  34. kutugun ismini bildirmek, ve yazmak istedigimizi belirtmektir. Bunu,
  35. "fopen" fonksiyonu ile yapiyoruz. "fp" isimli kutuk pointer'i, bu acilan
  36. kutuge ait bazi bilgileri tutar. "fopen" ise, iki parametre gerektirir.
  37. Birincisi, kutugun ismidir. Buyuk harf, kucuk harf, yada karisik fark
  38. etmez. 
  39.  
  40. OKUMAK "r"
  41.  
  42. "fopen" in ikinci parametresi ise, acilacak kutuk ile ne yapilacagini
  43. belirtir. Buraya, "r" "w" yada "a" yazabiliriz. "r" kullanildiginda, kutugun
  44. okuma icin acilacagini belirtir. "w", kutuge yazilacagini, ve "a" ise
  45. zaten var olan bir kutuge bilgi ekleyeceginizi belirtir. Bir kutugu okumak
  46. icin acmak icin, o kutugun diskte var olmasini geretirir. Sayet kutuk yok
  47. ise, "fopen", geriye NULL degerini dondurur.
  48.  
  49. YAZMAK "w"
  50.  
  51. Bir kutuk yazmak icin acilinca, sayet diskte yoksa yaratilir, sayet varsa,
  52. icindeki bilgiler silinir.
  53.  
  54. EKLEMEK "a"
  55.  
  56. Bir kutuk eklemek modunda acildiginda, sayet yoksa yaratilir, varsa, veri
  57. giris pointer'i bu kutugun sonuna ayarlanir. Bu sayede yeni bilgi
  58. yazilinca, kutugun sonuna yazilmis olur. 
  59.  
  60. KUTUGE YAZMAK
  61.  
  62. Bir kutuge yazmak, ekrana yazmak ile neredeyse aynidir. En onemli farklar,
  63. yeni fonksiyon isimleri, ve kutuk pointer'inin bu fonksiyonlara parametre
  64. olarak eklenmesidir. Ornek programda, "fprintf" komutu "printf" komutunun
  65. yerini alir. 
  66.  
  67. KUTUGU KAPATMAK
  68.  
  69. Bir kutugu kapatmak icin, sadece "fclose" komutunu kullanmak yeterlidir.
  70. Parametre olarak da kutugun pointer'ini gecirmek yeterlidir. DOS, program
  71. sona erince kullandigi kutukleri kapattigindan, "fclose" u kullanmak sart
  72. degildir, fakat bir aliskanlik yapmasi icin, kullandiginiz kutukleri
  73. kapatmanizi tavsiye ederim.
  74.  
  75. Bu programi calistirdiginizda, ekranda hicbir sey cikarmaz. Program
  76. bittikten sonra, "ONSATIR.TXT" isimli kutugu inceleyin. Icinde programin
  77. yazdigi on satirlik ciktiyi goreceksiniz.
  78.  
  79. KARAKTERLERI TEKER TEKER YAZMAK
  80.  
  81. KAROUT.C:
  82. ================================================================
  83. #include <stdio.h>
  84. main()
  85. {
  86. FILE *kutukpoint;
  87. char digerleri[35];
  88. int index,say;
  89.  
  90.    strcpy(digerleri,"Ek satirlar.");
  91.    kutukpoint = fopen("onsatir.txt","a"); /* eklemek icin acmak */
  92.  
  93.    for (say = 1;say <= 10;say++) {
  94.       for (index = 0;digerleri[index];index++)
  95.      putc(digerleri[index],kutukpoint);  /* bir karakter yaz  */
  96.       putc('\n',kutukpoint);             /* bir de <RETURN>   */
  97.    }
  98.    fclose(point);
  99. }
  100. ================================================================
  101.  
  102. Normal "include" kutugumuzden sonra, "kutukpoint" isimli bir kutuk
  103. pointeri tanimliyoruz. Yazacagimiz bilgileri tutmasi icin, "digerleri"
  104. isminde bir karakter dizisi tanimliyoruz. Daha sonra bu actigimiz sahaya,
  105. "strcpy" fonksiyonu ile "Ek satirlar." sozcugunu yaziyoruz. Bundan sonra,
  106. yine ayni kutugu "append" yani eklemek icin aciyoruz. 
  107.  
  108. Bu program iki tane ic ice donguden olusuyor. Distaki dongu, sadece birden
  109. ona kadar sayiyor.. Icindeki dongu ise, yazilan karakter sifir olmadigi
  110. surece, "putc" fonksiyonunu cagirir. 
  111.  
  112. "putc" FONKSIYONU
  113.  
  114. Bu programin ilgimizi ceken yonu, "putc" fonksiyonudur. Belirtilen kutuge
  115. bir karakter yazan bu fonksiyon, ilk parametre olarak yazilacak karakteri,
  116. ikinci olarak da kutuk pointer'ini veriyoruz. "Digerleri" isimli dizi
  117. bitince satirin sonuna bir <RETURN> karakteri koymak icin "putc" yi tekrar
  118. cagiriyoruz.
  119.  
  120. Dis dongu on kere tekrarlandiktan sonra, program kutugu kapatip sona
  121. eriyor. Bu program calistiktan sonra kutugu incelerseniz, gercektende
  122. sonuna 10 satir eklendigini gorursunuz.
  123.  
  124. BIR KUTUGU OKUMAK
  125.  
  126.  
  127. KAROKU.C:
  128. ================================================================
  129. #include <stdio.h>
  130.  
  131. main()
  132. {
  133. FILE *tuhaf;
  134. int c;
  135.  
  136.    tuhaf = fopen("ONSATIR.TXT","r");
  137.  
  138.    if (tuhaf == NULL) printf("Boyle bir kutuk yok\n");
  139.    else {
  140.       do {
  141.          c = getc(tuhaf);    /* Bir karakter oku  */
  142.          putchar(c);         /* ekranda goster    */
  143.       } while (c != EOF);    /* Kutuk sonuna (END OF FILE) a kadar devam */
  144.    }
  145.    fclose(tuhaf);
  146. }
  147. ================================================================
  148.  
  149. Bir kutuk okuyan ilk programimiz!  "stdio.h" ve iki degisken tanimindan
  150. sonra, "fopen" fonksiyonunda okumak icin "r" parametresini veriyoruz. Daha
  151. sonra, kutuk acmanin basarili olip olmadigini kontrol ediyoruz. Sayet
  152. basarili degilse, geriye NULL degeri donecektir.
  153.  
  154. Program, bir "do while" dongusunun icinde tek bir karakter okuyup, ekrana
  155. yaziyor. Bu dongu, ta ki, "getc" fonksiyonu kutugun sonunu belirten EOF
  156. dondurene kadar surer. EOF donunce de, kutuk kapatilir, ve program sona
  157. erer. 
  158.  
  159. DIKKAT DIKKAT DIKKAT
  160.  
  161. Bu noktada, C nin en sasirtici ve en cok yapilan hatasina rastliyoruz.
  162. "getc" fonksiyonundan geri donen degisken bir karakterdir, dolayisi ile
  163. bunu "char" tipi bir degiskene atayabiliriz. Hatirlayalim ki, bir "char"
  164. degiskeni 0 ila 255 arasindaki degerleri alabilir.
  165.  
  166. Fakat, cogu C derleyicilerinde EOF karakteri, -1 olarak tanimlanmistir -
  167. yani, "char" degiskeninin disinda - Bu nedenle sayet char kullanirsak,
  168. program kutugun sonunun geldigini bulamaz, ve sonsuz bir dongude takilir.
  169. Bunun onune gecmesi kolaydir: EOF karakteri donmesini beklediginiz
  170. durumlarda, daima "int" tipi bir degisken kullanin. 
  171.  
  172. Sayet sizin derleyiciniz icin EOF karakterinin ne oldugunu ogrenmek
  173. isterseniz, "stdio.h" isimli header'i okuyabilirsiniz.
  174.  
  175.  
  176. KELIME KELIME OKUMAK
  177.  
  178. TEXTOKU.C:
  179. ================================================================
  180. #include "stdio.h"
  181.  
  182. main()
  183. {
  184. FILE *fp1;
  185. char birkelime[100];
  186. int c;
  187.  
  188.    fp1 = fopen("ONSATIR.TXT","r");
  189.  
  190.    do {
  191.       c = fscanf(fp1,"%s",birkelime); /* kutukten bir kelime okuyalim */
  192.       printf("%s\n",birkelime);       /* ekrana yazalim               */
  193.    } while (c != EOF);              /* ta ki EOF olana kadar          */
  194.  
  195.    fclose(fp1);
  196. }
  197. ================================================================
  198.  
  199. Bu program, nerdeyse bir oncekinin aynisidir. Burada, kelime kelime okumak
  200. icin "fscanf" fonksiyonunu kullaniyoruz, cunku "fscanf" fonksiyonu, bir
  201. bosluga gelince, okumayi birakir. 
  202.  
  203. FAKAT BIR PROBLEM VAR
  204.  
  205. Programi inceleyince, verinin kutukten okundugunu, ekrana yazildigini ve
  206. daha sonra EOF olup olmadiginin kontrol edildigini goruyoruz. Bu nedenle,
  207. istemedigimiz birsey ekrana yazilmis oluyor. Buyuk ihtimalle, programin
  208. sonunda, en son kelimeyi bir daha yaziyoruz - cunku zaten "birkelime" nin
  209. icinde idi o deger. 
  210.  
  211. Buna mani olmak icin, bir baska program gorelim. Ismi IYIOKU.C olsun:
  212.  
  213. IYIOKU.C:
  214. ================================================================
  215. #include "stdio.h"
  216.  
  217. main()
  218. {
  219. FILE *fp1;
  220. char birkelime[100];
  221. int c;
  222.  
  223.    fp1 = fopen("onsatir.txt","r");
  224.  
  225.    do {
  226.       c = fscanf(fp1,"%s",birkelime); /* kutukten bir kelime oku... */
  227.       if (c != EOF)
  228.          printf("%s\n",birkelime);    /* ekrana yaz...            */
  229.    } while (c != EOF);              /* ta ki EOF olana dek..      */
  230.  
  231.    fclose(fp1);                      /* kutugu kapa       */
  232. }
  233. ================================================================
  234.  
  235. Gordugunuz gibi, bir "if" komutu ile, sayet kutugun sonuna gelip
  236. gelmedigimize bakiyoruz. Aslinda bu problem KAROKU.C da da vardi, fakat
  237. orada pek gorunmuyordu.
  238.  
  239. SONUNDA, BUTUN BIR SATIR OKUYORUZ
  240.  
  241. SATIROKU.C:
  242. ================================================================
  243.  
  244. #include "stdio.h"
  245.  
  246. main()
  247. {
  248. FILE *fp1;
  249. char birkelime[100];
  250. char *c;
  251.  
  252.    fp1 = fopen("ONSATIR.TXT","r");
  253.  
  254.    do {
  255.       c = fgets(birkelime,100,fp1); /* bir satir okuyalim */
  256.       if (c != NULL)
  257.          printf("%s",birkelime);    /* ekrana yazalim   */
  258.    } while (c != NULL);          /* ta ki NULL olana kadar.. */
  259.  
  260.    fclose(fp1);
  261. }
  262.  
  263. ================================================================
  264.  
  265. Bu program, simdiye de gorduklerimize benziyor, fakat NULL isimli yeni bir
  266. nesne de katildi. 
  267.  
  268. "fgets" fonksiyonu ile, bir butun satiri, ve sonundaki yeni satir
  269. karakterini (\n), bir diziye okur. Ilk parametre olarak, donen
  270. karakterleri koyacagimiz yerin adresi tanimlanir, ikinci parametrede en
  271. fazla kac karakter okunmasina izin verecegimizi belirtiyoruz, ve son
  272. olarak da kutuk degiskeninin ismini veriyoruz.
  273.  
  274.  o Yani bu fonksiyon, ya bir yeni satir karakterine rastlayana kadar, yada
  275. izin verilen karakter sayisi eksi bir kadar okur. Eksi birin sebebi ise,
  276. katarin sonunu belirten (\0)  sifir degerine yer birakmasidir.
  277.  
  278. Tabi sonunda, kutugu kapatiyoruz..
  279.  
  280. DEGISKEN BIR KUTUK ISMI
  281.  
  282. HERKUTUK.C:
  283. ================================================================
  284. #include "stdio.h"
  285.  
  286. main()
  287. {
  288. FILE *fp1;
  289. char birkelime[100],kutukismi[25];
  290. char *c;
  291.  
  292.    printf("Kutuk ismini girin -> ");
  293.    scanf("%s",kutukismi);         /* istenilen kutuk ismini alalim */
  294.  
  295.    fp1 = fopen(kutukismi,"r");
  296.  
  297.    do {
  298.       c = fgets(birkelime,100,fp1); /* kutukten bir satir okuyalim */
  299.       if (c != NULL)
  300.          printf("%s",birkelime);    /* ekrana yazalim       */
  301.    } while (c != NULL);          /* ta ki NULL olana kadar  */
  302.  
  303.    fclose(fp1);
  304. }
  305. ================================================================
  306.  
  307. Burada, ilk once kullanicidan "scanf" ile kutuk ismini kullanicidan
  308. aliyoruz, daha sonra kutugu acip, satir satir ekrana yaziyoruz.
  309.  
  310. YAZICIYA NASIL BIRSEY YOLLAYABILIRIZ
  311.  
  312. PRINTDAT.C:
  313. ================================================================
  314. #include "stdio.h"
  315.  
  316. main()
  317. {
  318. FILE *guzel,*printer;
  319. int c;
  320.  
  321.    guzel = fopen("onsatir.txt","r"); /* kutugu acalim        */
  322.    printer = fopen("PRN","w");        /* printeri acalim     */
  323.  
  324.    do {
  325.       c = getc(guzel);    /* kutukten bir karakter okuyoruz  */
  326.       if (c != EOF) {
  327.      putchar(c);      /* ekranda goruntuleyelim          */
  328.      putc(c,printer); /* ve yaziciya yollayalim          */
  329.       }
  330.    } while (c != EOF);    /* ta ki (End Of File) kutuk bitene kadar */
  331.  
  332.    fclose(guzel);
  333.    fclose(printer);
  334. }
  335. ================================================================
  336.  
  337. Okumak icin, "onsatir.txt" yi actiktan sonra, yazmak icin "PRN" isimli
  338. kutugu aciyoruz. Printere bir bilgi yollamak, ayni bir kutuge yazmak
  339. gibidir, fakat standart bir kutuk ismi kullanmak zorundayiz. Bu konuda
  340. kesin standartlar yoktur, fakat genellikle bu isimler "PRN" , "LPT",
  341. "LPT1" yada "LPT2" dir. 
  342.  
  343. Bazi yeni derleyicilerin, "stdprn" diye, onceden tanimli bir kutuk
  344. tanimliyicilari vardir. Bu sayede, siz printer'i bir kutuk gibi acmadan,
  345. ona veri yollayabilirsiniz.
  346.  
  347. Program, birer birer butun kutugu okuyup, ekranda gosterir, ve printer'e
  348. yollar. EOF , kutuk sonu bulundugunda, kutukler kapanir, ve programv
  349. biter. 
  350.  
  351.  
  352.  
  353. ODEVLER:
  354.  
  355. 1. Okunacak, yazilacak  kutuklerin isimlerini kullaniciya soran, daha
  356. sonra bu ikisini ve printer kutugunu acan bir program yazin. Program
  357. bunlari actiktan sonra, kutuk sonu gelinceye kadar okunacak kutugu harf
  358. harf okuyup, yazilacak kutuge ve yaziciya bu karakteri yollamalidir.
  359.  
  360. 2. Programiniz, kullaniciya bir kutuk ismi sorsun, cevabi alinca da, bu
  361. kutugu ekranda, satir numaralari ile birlikte gostersin..
  362.  
  363. <EOF>
  364.